#!/bin/bash
# Confirm the field actually exists on BotConfig.
rg -nP --type=py -C3 '\bunknown_user_policy\b'
ast-grep --pattern $'@dataclass
class BotConfig:
  $$$'
# Confirm TelegramAdapter import path the docs claim.
rg -nP --type=py -C2 '\bclass TelegramAdapter\b'
fd -a 'telegram*.py'

cat -n docs/features/bot-pairing.mdx

#!/bin/bash
rg -nP --type=py -C5 '\bclass\s+PairingStore\b'
rg -nP --type=py -C3 'TTL|ttl|expires?_in|code_ttl'

# Search for PairingStore class with focus on code TTL/expiry configuration
rg -A 30 'class PairingStore' praisonai/gateway/pairing.py

# Also check for any constants or defaults related to code expiry in the pairing module
rg -i 'code.*ttl|expires?|ttl.*code|default.*ttl' praisonai/gateway/pairing.py

# Verify the typo exists in the actual documentation file
cat -n docs/features/bot-pairing.mdx | sed -n '125,132p'

#!/bin/bash
rg -nP --type=py -C5 'PRAISONAI_GATEWAY_SECRET|\.gateway_secret|gateway_secret'

rg -n "gateway_secret" --type=py -i

fd -type f -name "*gateway*" | head -20

rg -n "\.gateway_secret|store_dir.*secret|gateway.*file|persist.*secret" --type=py

#!/bin/bash
rg -nP --type=py -C2 '\b(create_cli_clarify_handler|create_bot_clarify_handler|ClarifyHandler|ClarifyTool)\b'
rg -nP --type=py -C3 '^def\s+clarify\s*\('
fd -a 'clarify*.py'
ast-grep --pattern $'class Agent:
  $$$
  def __init__($$$):
    $$$'
rg -nP --type=py -C2 "clarify_handler"

fd -a 'clarify-tool.mdx' --exec cat {}

rg -n "from praisonaiagents" docs/features/clarify-tool.mdx

rg -rn "ctx=" docs/ --type=mdx | head -20

rg -rn "clarify" docs/ --type=mdx | grep -E "(import|from)" | head -20

fd -a 'README*' -o -a 'setup.py' -o -a 'pyproject.toml' | head -10

find . -name "pyproject.toml" -o -name "setup.py" -o -name "package.json" | head -5

git remote -v 2>/dev/null | head -10

rg -n "praisonaiagents" . --type=toml --type=json --type=txt | grep -E "(version|repository|url)" | head -20

ls -la | grep -E "(\.git|package|setup|pyproject|requirements)"

cat ./package.json

cat ./docs/package.json

rg -n "praisonaiagents" ./package.json ./docs/package.json

rg -rn "from praisonaiagents.tools" . --type=py 2>/dev/null | head -10

git log --oneline --all --grep="praisonaiagents" 2>/dev/null | head -5

find ./praisonaiagents -name "*clarify*" -type f

fd -a clarify ./praisonaiagents/

rg -n "def clarify\|class.*Clarify\|create_cli_clarify_handler\|create_bot_clarify_handler" ./praisonaiagents/ --type=py

ls -la ./praisonaiagents/tools/ | grep -E "(clarify|__init__)"

cat ./praisonaiagents/tools/__init__.py | head -100

ls -la ./praisonaiagents/tools/

rg -n "clarify" ./praisonaiagents/ --type=py -l

rg -n "from.*clarify\|import.*clarify" ./docs/features/clarify-tool.mdx

cat ./praisonaiagents/agent/deep_research_agent.py | grep -A5 -B5 clarify

cat ./praisonaiagents/tools/__init__.py | grep -i "clarify\|'clarify'"

rg -n "class Agent" ./praisonaiagents/agent/ --type=py -A 15 | head -50

find ./praisonaiagents -name "agent.py" -o -name "agents.py" | head -5

rg -n "def __init__" ./praisonaiagents/agent/agent.py -A 30 | head -80

grep -n "ctx" ./praisonaiagents/agent/agent.py | head -20

rg -n "class Agent" ./praisonaiagents/agent/agent.py -A 5

wc -l ./praisonaiagents/agent/agent.py

sed -n '509,650p' ./praisonaiagents/agent/agent.py

rg -n "ctx\s*[:=]" ./praisonaiagents/agent/agent.py | head -20

rg -n "self.ctx\s*=" ./praisonaiagents/agent/agent.py | head -20

sed -n '509,600p' ./praisonaiagents/agent/agent.py | grep -E "(ctx|context)"

rg -n "context.*=" ./praisonaiagents/agent/agent.py | head -30

cat ./praisonaiagents/tools/__init__.py | grep -A 200 "TOOL_MAPPINGS = {" | head -150

rg -rn "def clarify\|class Clarify" ./praisonaiagents/tools/ --type=py

cat ./praisonaiagents/tools/__init__.py | grep -i clarify

rg -rn "clarify" ./praisonaiagents/ --type=py -l

cat ./praisonaiagents/tools/__init__.py | tail -200

#!/bin/bash
ast-grep --pattern $'def clarify($$$): $$$'
ast-grep --pattern $'async def clarify($$$): $$$'

# Locate the file mentioned in the review
find . -name "clarify-tool.mdx" -type f

# Search for clarify function/class definition anywhere in the codebase
rg "def clarify|class clarify" -i -A 5

# Search for imports or usage of clarify in docs
rg "clarify" docs/ -A 2 -B 2 | head -100

# Read the clarify-tool.mdx file around the problematic lines
sed -n '250,280p' docs/features/clarify-tool.mdx

# Find and read the actual clarify function definition
find . -name "clarify.py" -type f | head -5

# Search for the clarify implementation in tools
rg "def clarify|async def clarify" -A 10 --type py

# Find the clarify tool implementation
find . -path "*/tools/clarify*" -type f

# Look for the actual clarify tool in praisonaiagents
rg "from praisonaiagents.tools.clarify import" -A 20

# Search for the clarify class or function definition in tools
find . -name "*.py" -path "*/tools/*" | xargs rg "class.*Clarify|def clarify" -l

# Search more broadly for clarify in praisonaiagents
rg "clarify" praisonaiagents/ -l --type py

# Look at the full context of lines around 263-274 to understand the fallback section
sed -n '230,290p' docs/features/clarify-tool.mdx

# Search for async function calls to understand the API better
rg "await.*clarify|clarify.*async" --type py

# Check if praisonaiagents/tools exists and list files
find praisonaiagents -type d -name "tools" 2>/dev/null

# Search all Python files for the actual clarify implementation with context
rg "clarify.*=" praisonaiagents/ -B 3 -A 3 --type py | head -80

# Check the actual import structure
cat praisonaiagents/__init__.py 2>/dev/null | grep -A 5 -B 5 "clarify" || echo "File not found or no clarify reference"

# List files in praisonaiagents/tools
ls -la praisonaiagents/tools/

# Check if there's a clarify.py file
cat praisonaiagents/tools/clarify.py 2>/dev/null | head -100

# Alternative - check __init__.py in tools
cat praisonaiagents/tools/__init__.py 2>/dev/null

# Search for any file containing "clarify" that might define the tool
find . -name "*.py" | xargs grep -l "class.*Clarify\|def.*clarify.*handler" 2>/dev/null | grep -v "__pycache__"

# Check if clarify module exists anywhere
find . -name "*clarify*" -type f 2>/dev/null

# Search for the import statement in the docs to understand what's expected
rg "from praisonaiagents.tools.clarify import" docs/ -B 5 -A 10

# Double-check the tools __init__.py for any mention of clarify
rg "clarify" praisonaiagents/tools/__init__.py

# Check git to see if clarify was removed or if it's an incomplete feature
git log --all --oneline --follow --name-status -- "*clarify*" 2>/dev/null | head -20

# Verify the import statement works or fails
python3 -c "from praisonaiagents.tools.clarify import clarify" 2>&1 || echo "Import failed as expected"

# Check if there's any clarify implementation elsewhere
rg "def clarify|async def clarify" --type py praisonaiagents/ -B 2 -A 5

# Get full context of the fallback section and surrounding content
sed -n '240,300p' docs/features/clarify-tool.mdx

#!/bin/bash
# Confirm the runtime actually invokes check_availability() and exposes the documented registry APIs.
rg -nP --type=py -C3 '\bcheck_availability\s*\('
rg -nP --type=py -C3 '\bToolAvailabilityProtocol\b'
rg -nP --type=py -C3 '\b(list_available_tools|get_registry|register_tool)\b'
ast-grep --pattern $'@tool(availability=$_)
def $_($$$): $$$'
rg -nP --type=py -C5 'def\s+(get_tool_schema|_generate_parameters_schema)\b'

# Find and examine BaseTool implementation
fd -t f base.py | grep -E "tools/base\.py"

# Look at the BaseTool class and check_availability implementation
rg -A30 "class BaseTool" --type=py -e "praisonaiagents/tools/base.py"

# Search for where check_availability is actually called during tool setup/schema generation
rg -B3 -A5 "check_availability" --type=py

# Check the get_tool_schema function to see if it calls availability checking
rg -B5 -A15 "def get_tool_schema" --type=py

# Read the base.py file to see BaseTool implementation
cat praisonaiagents/tools/base.py

# Search for ToolAvailabilityProtocol or any availability protocol
rg "ToolAvailabilityProtocol|AvailabilityProtocol" --type=py

# Check if availability is checked during tool execution
rg "available|availability" --type=py praisonaiagents/agent/tool_execution.py -C2

# Verify the documentation file exists and check its content around the problematic section
cat docs/features/tool-availability.mdx 2>/dev/null | head -100

# Check if `@tool` decorator supports availability parameter
rg -B5 -A20 "def tool\(" praisonaiagents/tools/decorator.py

# Check the full decorator.py to see if availability is mentioned
rg "availability" praisonaiagents/tools/decorator.py -C3

#!/bin/bash
fd -e mdx . docs/features | head -50

#!/bin/bash
# Search for tools and agents related pages in docs/features
echo "=== Searching for 'tools' in docs/features/ ==="
fd -e mdx . docs/features -x grep -l 'tools' {} \; | head -20

echo -e "\n=== Searching for 'agents' in docs/features/ ==="
fd -e mdx . docs/features -x grep -l 'agents' {} \; | head -20

echo -e "\n=== Checking for exact 'tools' or 'agents' pages ==="
fd -e mdx . docs/features | grep -E '(^docs/features/tools|^docs/features/agents)\.mdx$'

#!/bin/bash
# Check all feature page filenames to see what exists
echo "=== All docs/features/ filenames (full list) ==="
fd -e mdx . docs/features | sort